﻿#define _CRT_SECURE_NO_WARNINGS 1



#include<iostream>
using namespace std;
#include<string>
#include<vector>
//class Student
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{ /*...*/ }
//	// 学习
//	void study()
//	{ /*...*/ }
//protected:
//	string _name = "peter"; // 姓名
//	string _address; // 地址
//	string _tel; // 电话
//	int _age = 18; // 年龄
//	int _stuid; // 学号
//};
//
//class Teacher
//{
//public:// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{ /*...*/ }
//	// 授课
//	void teaching()
//	{ /*...*/ }
//protected:
//	string _name = "张三"; // 姓名
//	int _age = 18; // 年龄
//	string _address; // 地址
//	string _tel; // 电话
//	string _title; // 职称
//};




//class Person {
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		cout << "void identity()" << _name << endl;
//	}
//protected:
//	string _name = "张三"; // 姓名
//	string _address; // 地址
//	string _tel; // 电话
//	int _age = 18; // 年龄
//private:
//	int _id; // 身份证
//};
//
//class Student : public Person {
//public:
//	// 学习
//	void study()
//	{ 
//		//cout<< _id << endl;继承下来了但不能直接访问
//	}
//protected:
//	int _stuid; // 学号
//};
//
//class Teacher : public Person {
//public:
//	// 授课
//	void teaching()
//	{ /*...*/ }
//protected:
//	string title; // 职称
//};



//int main()
//{
//	Student s;
//	Teacher t;
//	s.identity();
//	t.identity();
//	return 0;
//}



//基类定义
class Base {
public:
	int publicVar;

	void publicFunc() {
		cout << "Base public function" << endl;
	}

protected:
	int protectedVar;

	void protectedFunc() {
		cout << "Base protected function" << endl;
	}

private:
	int privateVar;

	void privateFunc() {
		cout << "Base private function" << endl;
	}
};

/////////////////////public继承演示//////////////////////////////
class PublicDerived : public Base {
public:
	void testAccess() {
		cout << "=== Public继承测试 ===" << endl;

		publicVar = 10;        // ✅ 可以访问，保持public权限
		publicFunc();          // ✅ 可以访问，保持public权限

		protectedVar = 20;     // ✅ 可以访问，保持protected权限
		protectedFunc();       // ✅ 可以访问，保持protected权限

		cout << "publicVar: " << publicVar << endl;
		cout << "protectedVar: " << protectedVar << endl;
	}
};
void testPublicInheritance() {
	PublicDerived obj;

	obj.testAccess();          // ✅ 可以调用派生类的public方法

	// 在类外部访问
	obj.publicVar = 100;       // ✅ 可以访问，保持public权限
	obj.publicFunc();          // ✅ 可以访问，保持public权限

	// obj.protectedVar = 200; // ❌ 错误：protected成员不能在类外访问
	// obj.protectedFunc();    // ❌ 错误：protected成员不能在类外访问
}

/////////////////////protected继承演示/////////////////////////////
class ProtectedDerived : protected Base {
public:
	void testAccess() {
		cout << "=== Protected继承测试 ===" << endl;

		// 在派生类内部访问
		publicVar = 10;        // ✅ 可以访问，但变为protected权限
		publicFunc();          // ✅ 可以访问，但变为protected权限

		protectedVar = 20;     // ✅ 可以访问，保持protected权限  
		protectedFunc();       // ✅ 可以访问，保持protected权限

		// privateVar = 30;    // ❌ 错误：基类private成员不可访问
		// privateFunc();      // ❌ 错误：基类private成员不可访问

		cout << "publicVar: " << publicVar << endl;
		cout << "protectedVar: " << protectedVar << endl;
	}
};
void testProtectedInheritance() {
	ProtectedDerived obj;

	obj.testAccess();          // ✅ 可以调用派生类的public方法

	// 在类外部访问
	// obj.publicVar = 100;    // ❌ 错误：publicVar在派生类中变为protected
	// obj.publicFunc();       // ❌ 错误：publicFunc在派生类中变为protected
	// obj.protectedVar = 200; // ❌ 错误：protected成员不能在类外访问
	// obj.protectedFunc();    // ❌ 错误：protected成员不能在类外访问
}

//////////////////////private继承演示////////////////////////////
class PrivateDerived : private Base {
public:
	void testAccess() {
		cout << "=== Private继承测试 ===" << endl;

		// 在派生类内部访问
		publicVar = 10;        // ✅ 可以访问，但变为private权限
		publicFunc();          // ✅ 可以访问，但变为private权限

		protectedVar = 20;     // ✅ 可以访问，但变为private权限
		protectedFunc();       // ✅ 可以访问，但变为private权限

		// privateVar = 30;    // ❌ 错误：基类private成员不可访问
		// privateFunc();      // ❌ 错误：基类private成员不可访问

		cout << "publicVar: " << publicVar << endl;
		cout << "protectedVar: " << protectedVar << endl;
	}

	// 如果需要暴露某些基类接口，需要手动包装
	void exposedPublicFunc() {
		publicFunc();  // 在内部调用，然后暴露给外部
	}
};
void testPrivateInheritance() {
	PrivateDerived obj;

	obj.testAccess();          // ✅ 可以调用派生类的public方法
	obj.exposedPublicFunc();   // ✅ 通过包装方法访问

	// 在类外部直接访问基类成员
	// obj.publicVar = 100;    // ❌ 错误：publicVar在派生类中变为private
	// obj.publicFunc();       // ❌ 错误：publicFunc在派生类中变为private
	// obj.protectedVar = 200; // ❌ 错误：protectedVar在派生类中变为private
	// obj.protectedFunc();    // ❌ 错误：protectedFunc在派生类中变为private
}

#include<list>

//#define CONTATNER std::vector

#define CONTATNER std::list
namespace name
{
	//template<class T>
	//class vector
	//{};
	// stack和vector的关系，既符合is-a，也符合has-a
	//template<class T>
	//class stack : public std::vector<T>
	//{
	//public:
	//	void push(const T& x)
	//	{
	//		// 基类是类模板时，需要指定⼀下类域，
	//		// 否则编译报错:error C3861: “push_back”: 找不到标识符
	//		// 因为stack<int>实例化时，也实例化vector<int>了
	//		// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
	//		vector<T>::push_back(x);
	//		//push_back(x);
	//	}
	//	void pop()
	//	{
	//		vector<T>::pop_back();
	//	}
	//	const T& top()
	//	{
	//		return vector<T>::back();
	//	}
	//	bool empty()
	//	{
	//		return vector<T>::empty();
	//	}
	//};

	//template<class T>
	//class stack : public std::list<T>
	//{
	//public:
	//	void push(const T& x)
	//	{
	//		list<T>::push_back(x);
	//	}
	//	void pop()
	//	{
	//		list<T>::pop_back();
	//	}
	//	const T& top()
	//	{
	//		return list<T>::back();
	//	}
	//	bool empty()
	//	{
	//		return list<T>::empty();
	//	}
	//};

	
	template<class T>
	class stack : public CONTATNER<T>
	{
	public:
		void push(const T& x)
		{
			CONTATNER<T>::push_back(x);
		}
		void pop()
		{
			CONTATNER<T>::pop_back();
		}
		const T& top()
		{
			return CONTATNER<T>::back();
		}
		bool empty()
		{
			return CONTATNER<T>::empty();
		}
	};
}



//int main()
//{
//	name::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//	return 0;
//}



//class Person
//{
//	virtual void func()
//	{
//	}
//protected:
//	string _name; // 姓名
//	string _sex; // 性别
//	int _age; // 年龄
//};
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//int main()
//{
//	Student sobj;
//	// 1.派⽣类对象可以赋值给基类的指针/引⽤
//	Person* pp = &sobj;
//	Person& rp = sobj;
//	// ⽣类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的
//	Person pobj = sobj;
//
//	//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
//	//sobj = pobj;
//	//sobj = (Student)pobj;强制类型转换也不行
//
//	//Student* ps = pp;err
//	//Student* ps = (Student*)pp;ok但是危险
//	Student* ps1 = dynamic_cast<Student*> (pp);
//	cout << ps1 << endl;
//
//	pp = &pobj;
//	Student* ps2 = dynamic_cast<Student*> (pp);
//	cout << ps2 << endl;
//	return 0;
//}



// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆
//class Person
//{
//protected:
//	string _name = "小李子"; // 姓名
//	int _num = 111; // ⾝份证号
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " 身份证号:" << Person::_num << endl;
//		cout << " 学号:" << _num << endl;
//	}
//protected:
//	int _num = 999; // 学号
//};
//int main()
//{
//	Student s1;
//	s1.Print();
//	return 0;
//}






class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		cout << "func(int i)" << i << endl;
	}
};
//int main()
//{
//	B b;
//	b.fun(10);
//	/*b.fun();*/
//	b.A::fun();
//	return 0;
//};



class Person
{
public:
	Person(const char* name= "Peter")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person & p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person & p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class Student :public Person
{
public:
	//假设父类不提供默认构造比如将缺省值“Peter”去掉，子类就要提供构造函数用初始化列表调用父类的构造函数
	Student(const char* name, int num, const char* address)
		:_num(num)
		,_address(address)
		,Person(name)
	{}
	Student(const Student& s)
		:Person(s)//显示调用父类的拷贝构造
		, _num(s._num)
		, _address(s._address)
	{
		//这里写深拷贝
		//子类不写拷贝构造：编译器生成完整的拷贝构造，自动调用父类拷贝构造
		//写了拷贝构造但没调用父类：
		//父类有默认构造 → 编译通过，但逻辑错误
		//父类无默认构造 → 编译错误
	}
	Student& operator=(const Student& s)
	{
		if (this!=&s)//防止给自己复制
		{
			//operator=(s);//无穷递归，调用自己err
			Person::operator=(s);
			_num = s._num;
			_address = s._address;
		}
		return *this;
	}

	~Student()
	{
		//_num不用管，_address成员自动调用string的析构
		//~Person();err//析构可以显式调用，但是子类的析构和父类的析构构成隐藏关系
		Person::~Person();//错误X
	}
	
protected:
	int _num;//不确定
	string _address;//调用string的默认构造
	//父类成员---->调用父类默认构造
};


//int main()
//{
//	/*Student s;*/
//	Student s1("Alex",19,"China");
//	Student s2(s1);
//	return 0;
//}
//class Student : public Person
//{
//public:
//	Student(const char* name, int num)
//		: Person(name)
//		, _num(num)
//	{
//		cout << "Student()" << endl;
//	}
//	Student(const Student& s)
//		: Person(s)
//		, _num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//	Student& operator = (const Student& s)
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s) {
//			// 构成隐藏，所以需要显⽰调⽤
//			Person::operator =(s);
//			_num = s._num;
//		}
//		return *this;
//	}
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号
//};

//int main()
//{
//	Student s1("jack", 18);
//	Student s2(s1);
//	Student s3("rose", 17);
//	s1 = s3;
//	return 0;
//}




//class Baseclass final// C++11的⽅法
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的⽅法
//	Baseclass()
//	{}
//};
//
//class Derive :public Baseclass
//{
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//
//int main()
//{
//	/*Baseclass b;
//	Derive d;*/
//	return 0;
//}





